package com.wingice.utils.dictionary;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.wingice.system.entity.SysDictionaryItem;
import com.wingice.system.service.SysDictionaryItemService;
import com.wingice.system.service.SysDictionaryService;
import com.wingice.system.vo.dictionary.DictionaryView;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 字典工具类
 */
@Component
public class DictionaryUtil {
    @Resource
    private SysDictionaryService dictionaryService;
    @Resource
    private SysDictionaryItemService dictionaryItemService;

    private static DictionaryUtil dictionaryUtil;

    @PostConstruct
    public void init() {
        dictionaryUtil = this;
        dictionaryUtil.dictionaryService = this.dictionaryService;
        dictionaryUtil.dictionaryItemService = this.dictionaryItemService;
    }

    private DictionaryUtil() {
    }

    /**
     * 根据module或的原数据列表
     *
     * @param code 字典code
     * @return 字典信息对象集合
     * @date 2021/3/31 10:55
     */
    public static List<SysDictionaryItem> getList(String code) {
        if (StrUtil.isBlank(code)) {
            return new ArrayList<>();
        }
        return dictionaryUtil.dictionaryService.getList(code);
    }

    /**
     * 根据module或的原数据列表MAP
     *
     * @param codeList 字典code集合
     * @return 字典信息对象集合Map module - itemList
     * @date 2021/3/31 10:55
     */
    public static Map<String, List<SysDictionaryItem>> getListMap(List<String> codeList) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getListMap(codeList);
    }


    /**
     * 根据code 获得展示类列表
     *
     * @param code 字典code
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static List<DictionaryView> getDictionaryList(String code) {
        if (StrUtil.isBlank(code)) {
            return new ArrayList<>();
        }
        return dictionaryUtil.dictionaryService.getDictionaryList(code);
    }

    /**
     * 根据code 获得展示类列表
     *
     * @param code    字典code
     * @param reverse 是否反转
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static List<DictionaryView> getDictionaryList(String code, boolean reverse) {
        if (StrUtil.isBlank(code)) {
            return new ArrayList<>();
        }
        return dictionaryUtil.dictionaryService.getDictionaryList(code, reverse);
    }

    /**
     * 根据code 获得展示类列表Map
     *
     * @param codeList 字典code集合
     * @return 字典信息展示对象集合Map
     * @date 2021/3/31 10:55
     */
    public static Map<String, List<DictionaryView>> getDictionaryListMap(List<String> codeList) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getDictionaryListMap(codeList);
    }

    /**
     * 根据code 获得展示类列表Map
     *
     * @param codeList 字典code集合
     * @param reverse  是否反转 key value 互换
     * @return 字典信息展示对象集合Map
     * @date 2021/3/31 10:55
     */
    public static Map<String, List<DictionaryView>> getDictionaryListMap(List<String> codeList, boolean reverse) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getDictionaryListMap(codeList, reverse);
    }

    /**
     * 根据code 获得字典项值的集合
     *
     * @param code 字典code
     * @return 获得字典项值的集合
     * @date 2021/3/31 10:55
     */
    public static List<String> getDictionaryValueList(String code) {
        if (StrUtil.isBlank(code)) {
            return new ArrayList<>();
        }
        return dictionaryUtil.dictionaryService.getDictionaryValueList(code);
    }

    /**
     * 根据code 获得字典项值Map的集合
     *
     * @param codeList 字典codeList
     * @return 获得字典项值的集合
     * @date 2021/3/31 10:55
     */
    public static Map<String, List<String>> getDictionaryValueListMap(List<String> codeList) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getDictionaryValueListMap(codeList);
    }

    /**
     * 根据code 获得字典项map
     *
     * @param code 字典code
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static Map<String, String> getDictionaryMap(String code) {
        if (StrUtil.isBlank(code)) {
            return new HashMap<>(10);
        }
        return dictionaryUtil.dictionaryService.getDictionaryMap(code);
    }

    /**
     * 根据code 获得字典项map
     *
     * @param code    字典code
     * @param reverse 是否反转 key value 互换
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static Map<String, String> getDictionaryMap(String code, boolean reverse) {
        if (StrUtil.isBlank(code)) {
            return new HashMap<>(10);
        }
        return dictionaryUtil.dictionaryService.getDictionaryMap(code, reverse);
    }

    /**
     * 根据code 获得字典项map 根据字典code进行分组
     *
     * @param codeList 字典code
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static Map<String, Map<String, String>> getDictionaryMapMap(List<String> codeList) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getDictionaryMapMap(codeList);
    }

    /**
     * 根据code 获得字典项map 根据字典code进行分组
     *
     * @param codeList 字典code集合
     * @param reverse  是否反转 key value 互换
     * @return 字典信息展示对象集合
     * @date 2021/3/31 10:55
     */
    public static Map<String, Map<String, String>> getDictionaryMapMap(List<String> codeList, boolean reverse) {
        if (CollectionUtil.isEmpty(codeList)) {
            return new HashMap<>(1);
        }
        return dictionaryUtil.dictionaryService.getDictionaryMapMap(codeList, reverse);
    }

}
